package com.irene.algui;
import android.content.Context;
import android.graphics.Typeface;
import android.graphics.drawable.GradientDrawable;
import android.text.Editable;
import android.view.Gravity;
import android.view.View;
import android.view.animation.Animation;
import android.widget.CompoundButton;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.SeekBar;
import android.widget.TextView;
import irene.window.algui.AlGui;
import irene.window.algui.AlGuiBubbleNotification;
import irene.window.algui.AlGuiData;
import irene.window.algui.AlGuiDialogBox;
import irene.window.algui.AlGuiSoundEffect;
import irene.window.algui.AlGuiWindowView;
import irene.window.algui.Tools.VariousTools;
import java.util.Locale;

public class Algui {

    public static final String TAG = "冰雪";
    private static Context context;

    //启动ALGUI的方法
    public static void start(Context aContext) {
        if (aContext == null) {
            return;
        }
        context = aContext;

        AlGuiBubbleNotification.Inform(context).showMessageNotification_Exquisite(null, "冰雪科技", "", 5000);
        //语音播报功能 参数{上下文，播报内容，机器人语言}
        
        initConfigurations();//初始化ALGUI配置
        if (AlguiNetworkVerification.getObject(context).getIO()) {
            AlguiNetworkVerification.getObject(context).start();
        } else {
            initMenu();
        }
        AlGui.GUI(context).showBall();//ALGUI加载完成后 调用showBall方法来显示悬浮球
        //AlGui.GUI(context).showMenu();//你也可以选择调用showMenu方法来先显示悬浮菜单
    }

    //📍ALGUI配置
    //ps：你也可以选择将你自己美化的ALGUI配置分享给其他人使用，或者你有能力也可以加入主题功能😋
    private static void initConfigurations() {
        //文本相关📝
        AlGui.GUI(context).getMenuMainTitle().setText("冰雪科技");//设置ALGUI主标题文本
        AlGui.GUI(context).getMenuSubTitle().setText("版本：5.7");//设置ALGUI副标题文本
        AlGui.GUI(context).getMenuExplanation().setText("作者：仅供用于学习交流请勿用于违法用途");//设置ALGUI说明信息文本 (如果启动了网络验证那么说明信息为网络验证公告)
        
        //属性相关⚙️
        AlGui.GUI(context).setBallImage("tb.png", 35, 35);//设置ALGUI悬浮球图片(支持gif|png|jpg…) {参数：Assets文件夹下的图片名(null代表不使用图片而是默认MOD视图)，悬浮球宽高}
        //AlGui.GUI(context).setBallImage("icon.png", 50, 50);//示例：这样设置悬浮球可以将assets文件夹下的icon.png图片文件设置为悬浮球
        AlGui.GUI(context).setAllViewMargins(15, 5, 15, 5);//设置ALGUI滚动菜单内所有视图的外边距 {参数：左，上，右，下的外边}
        AlGuiData.menuScrollWidth = 600f;//设置ALGUI窗口初始宽度
        AlGuiData.menuScrollHeight = 750f;//设置ALGUI窗口初始高度
        AlGuiData.rootLayoutFilletRadius = 5f; //设置ALGUI窗口圆角半径
        AlGuiData.rootLayoutStrokeWidth = 1f;//设置ALGUI窗口描边宽度
        AlGuiData.menuTopLineFilletRadius = 1f;//设置ALGUI顶部状态线条的圆角半径
        AlGuiData.menuTransparency = 1f; //设置ALGUI窗口透明度 (透明度范围在0和1之间)


        //颜色相关🎨
        AlGuiData.rootLayoutBackColor = 0x75000000;//设置ALGUI窗口主背景颜色 (可以理解为上下边栏的颜色)
        AlGuiData.rootLayoutStrokeColor = 0xFF616161;//设置ALGUI窗口描边颜色
        AlGuiData.menuTopLineColor = 0x50000000;//设置ALGUI顶部移动状态线条未高亮时的颜色 (高亮颜色暂不支持设置)
        AlGuiData.menuMainTitleTextColor = 0xFFFFFFFF;//设置ALGUI主标题文本颜色
        AlGuiData.menuSubTitleTextColor = 0x60FFFFFF;//设置ALGUI副标题文本颜色
        AlGuiData.menuExplanationBackColor = 0x60FFFFFF;//设置ALGUI说明信息背景颜色
        AlGuiData.menuExplanationTextColor = 0xFFFFFFFF;//设置ALGUI说明信息文本颜色
        AlGuiData.menuScrollBackColor = 0x00000000;//设置ALGUI滚动菜单背景颜色
        AlGuiData.menuBottLeftButtonTextColor = 0xFFFFFFFF;//设置ALGUI左下角按钮文本颜色
        AlGuiData.menuBottRightButtonTextColor = 0xFFFFFFFF;//设置ALGUI右下角按钮文本颜色
        AlGuiData.menuBottRightTriangleColor = 0xFF616161;//设置ALGUI右下角可拉拽缩放窗口的边角颜色

        //配置完成后不要忘记更新ALGUI，否则可能无效😋
        AlGui.GUI(context).updateMenuAppearance();//更新ALGUI外观
        AlGui.GUI(context).updateMenu();//更新ALGUI窗口
    }

    //📍ALGUI滚动菜单
    public static void initMenu() {
        //💥ALGUI 内存修改说明：
        //友情提醒：内存修改仅供单机游戏MOD功能娱乐使用，请勿用在网络游戏上后果自负
        //ALGUI内存修改拥有两种方式：
        //❶ 使用ALGUI内置的Java内存修改 实现游戏修改 (支持32位/64位游戏)
        //注意事项：制作直装包时将ALGUI的lib文件夹中对应32或64位文件夹的Modification.so库文件移动至游戏lib文件夹下对应32/64文件夹中
        //如果游戏只有32位文件夹，那么你只能移动32位的Modification.so文件，否则闪退，64同理
        //示例：
        /*AlguiMemory.clearResult();//清空搜索结果
         AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
         AlguiMemory.setPackageName("com.yodo1.SkiSafari.yodo1");//设置包名
         AlguiMemory.RangeMemorySearch("-50", AlguiMemory.TYPE_FLOAT);//主特征码
         AlguiMemory.MemoryOffset("1000", AlguiMemory.TYPE_FLOAT, -12);//副特征码
         AlguiMemory.MemoryOffset("-10", AlguiMemory.TYPE_FLOAT, 4);//副特征码
         AlguiMemory.MemoryOffset("90", AlguiMemory.TYPE_FLOAT, 12);//副特征码
         //副特征码如果不够就像上面这样添加
         AlguiMemory.MemoryWrite("0", AlguiMemory.TYPE_FLOAT, 8);//修改值
         //修改值不够就像上面这样添加
         AlguiMemory.clearResult();//清空搜索结果*/      

        //➋ 执行第三方编译好的C++二进制文件 实现游戏修改 (支持32位/64位游戏)
        //示例：
        //这将自动在游戏安装包lib文件夹下检测此二进制文件，如果检测到就执行
        //请务必将二进制文件放进游戏安装包lib文件夹的32和64文件夹中，否则它将不会执行
        //并且二进制文件命名也很重要，你的二进制名称前缀必须是lib后缀名必须是so，例如libtest.so 如果你不是那么很有可能执行失败
        //HackerTool.linuxHackerFile(context, "二进制文件名称");

		//添加一个折叠菜单
        LinearLayout 折叠菜单1= AlGui.GUI(context).addCollapse
        ( 
            AlGui.GUI(context).getMenuScrollingListLayout(),//父布局
            "功能菜单", 16, 0xFFFF0DFF, null,//折叠菜单文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
            3,//折叠菜单圆角半径
            0x6600FFFF,//折叠菜单背景颜色
            0, 0xFFC5CAE9,//折叠菜单描边大小，描边颜色
            false//折叠菜单默认是否展开 (true=默认展开，false=默认不展开)
        );

        //添加一条线 {参数：父布局，线的厚度，线的颜色，线的方向(true=横向 false=竖向)}
        AlGui.GUI(context).addLine(折叠菜单1, 1f, 0xFFE0E0E0, true);

        //添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
        AlGui.GUI(context).addTextView(折叠菜单1, "功能区", 11, 0xE3FF00FF, null);
	
		
		
		
		
		
		
		
		AlGui.GUI(context).addTextView(折叠菜单1, "可以自定义输入加速多少倍加0.14为正常速度", 11, 0xE3FF00FF, null);


		//添加一个带按钮的输入框
        AlGui.GUI(context).addEditText
        (
			折叠菜单1,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "0.2", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "启动加速", //按钮文本颜色，按钮文本
            0, 0xFF5492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_CODE_APP);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("-0.69999998808", AlguiMemory.TYPE_FLOAT);//主特征码
                       

						AlguiMemory.MemoryWriteFreeze(editText, AlguiMemory.TYPE_FLOAT, 0x8);//修改值
						
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "加速成功", "修改成功！", 5000);
                    } else {
                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		AlGui.GUI(context).addEditText
        (
			折叠菜单1,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "0.14", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "关闭加速", //按钮文本颜色，按钮文本
            0, 0xFF5492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {
						AlguiMemory.stopFreeze();//关闭冻结线程
						AlguiMemory.setRange(AlguiMemory.RANGE_CODE_APP);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("-0.69999998808", AlguiMemory.TYPE_FLOAT);//主特征码
						AlguiMemory.MemoryWriteFreeze(editText, AlguiMemory.TYPE_FLOAT, 8);//修改值
						
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "加速成功", "修改成功！", 5000);
                    } else {
                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );

		
		
		//添加一个开关按钮
		AlGui.GUI(context).addSwitch
		(
		//开关按钮属性配置🛠️
		折叠菜单1,
		//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
		"开启自动满怒气(注意说明)", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：必须要一格怒气或者三格满怒气才能激活只需要激活一次即可", 9, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
			@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
			public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
			//开关按钮点击时将执行这里的内容
			//这将获取到开关的文本
				String switchText = aSwitch.getText().toString();
				//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
					//开启时执行的内容

					AlguiMemory.clearResult();//清空搜索结果    AlguiMemory.clearResult();//清空搜索结果
					AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("10000", AlguiMemory.TYPE_DOUBLE);//主特征
				    	AlguiMemory.MemoryOffset("0.0", AlguiMemory.TYPE_DOUBLE, 0x58);//副特征	
				    	AlguiMemory.MemoryOffset("0.0", AlguiMemory.TYPE_DOUBLE, 0x70);//副特征码
						
					    
						AlguiMemory.RangeMemorySearch("30000", AlguiMemory.TYPE_DOUBLE);//主特征
				        AlguiMemory.MemoryOffset("0.0", AlguiMemory.TYPE_DOUBLE, 0x58);//副特征	
					    AlguiMemory.MemoryOffset("0.0", AlguiMemory.TYPE_DOUBLE, 0x70);//副特征码
					
						AlguiMemory.MemoryWriteFreeze("30000", AlguiMemory.TYPE_DOUBLE, 0x0);//修改值
						//修改值不够就像上面这样添加
						AlguiMemory.startFreeze();
						AlguiMemory.clearResult();//清空搜索结果    




						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "开启成功！", 2000);

                        } else {
						//关闭时执行的内容


					//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "无法关闭！", 2000);
                        }
						}
						}

					);
				
		


        
        
        
        
    
         
        
        
        
        
        
		
		
		AlGui.GUI(context).addSwitch
        (
            折叠菜单1,
			//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"完美锁鱼", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：支持所有杆子锁0米还会跑", 8, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
				@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
				public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
					//开关按钮点击时将执行这里的内容
					//这将获取到开关的文本
					String switchText = aSwitch.getText().toString();
					//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
						//开启时执行的内容
						AlguiMemory.clearResult();//清空搜索结果
						AlguiMemory.setRange(AlguiMemory.RANGE_CODE_APP);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名

						AlguiMemory.RangeMemorySearch("0.001", AlguiMemory.TYPE_FLOAT);//主特征码
                        AlguiMemory.MemoryOffset("0.0", AlguiMemory.TYPE_FLOAT, 0xC);//副特征码
						

						AlguiMemory.MemoryWrite("0", AlguiMemory.TYPE_FLOAT, 0);//修改值
						//修改值不够就像上面这样添加
					    
						AlguiMemory.clearResult();//清空搜索结果*/      

						
						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "此功能无法关闭需要重启游戏恢复正常", "开启成功！", 5000);

					} else {
						//关闭时执行的内容

						//修改值不够就像上面这样添加

						

						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "关闭成功！", 5000);
					}
				}
			}

        );
		
		
		        
        AlGui.GUI(context).addSwitch
		(
			//开关按钮属性配置🛠️
			折叠菜单1,
			//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"蓝杆无限怒气", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：需激活要3星有可以不用激活", 9, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
				@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
				public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
					//开关按钮点击时将执行这里的内容
					//这将获取到开关的文本
					String switchText = aSwitch.getText().toString();
					//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
						//开启时执行的内容

						//修改值不够就像上面这样添加
						AlguiMemory.clearResult();//清空搜索结果    AlguiMemory.clearResult();//清空搜索结果
						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名

						AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
						AlguiMemory.MemoryOffset("150", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码

						AlguiMemory.MemoryWrite("600000", AlguiMemory.TYPE_DOUBLE, 0x18);//修改值
                        AlguiMemory.MemoryWrite("1050", AlguiMemory.TYPE_DOUBLE, 0x0);//修改值

						//修改值不够就像上面这样添加
						AlguiMemory.clearResult();//清空搜索结果    




						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "开启成功！", 2000);

					} else {
					
		
						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "无法关闭！", 2000);
					}
				}
			}

        );
        
        
        AlGui.GUI(context).addSwitch
            (
                //开关按钮属性配置🛠️
				折叠菜单1,
                //开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
                "紫杆无限怒气", 11, 0xFFFFFFFF, null,
                //开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
                "说明：需激活要3星有可以不用激活", 9, 0xE4FF1700, null,
                //开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
                0xFF4CAF50, 0xFF66BB6A,
                //开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
                0xFFF44336, 0xFFEF5350,
                //开关按钮事件监听器
                new AlGui.T_SwitchOnChangeListener(){
                    @Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
                    public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
                        //开关按钮点击时将执行这里的内容
                        //这将获取到开关的文本
                        String switchText = aSwitch.getText().toString();
                        //这将获取到描述信息的文本
                        String descText=desc.getText().toString();
                        //isChecked为开关状态
                        if (isChecked) {
                            //开启时执行的内容
						
							//修改值不够就像上面这样添加
							AlguiMemory.clearResult();//清空搜索结果    AlguiMemory.clearResult();//清空搜索结果
							AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
							AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
					
							AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
							AlguiMemory.MemoryOffset("200", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
							
								AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
							AlguiMemory.MemoryOffset("400", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
							
						AlguiMemory.MemoryWrite("600000", AlguiMemory.TYPE_DOUBLE, 0x18);//修改值
                        AlguiMemory.MemoryWrite("1050", AlguiMemory.TYPE_DOUBLE, 0x0);//修改值

							//修改值不够就像上面这样添加
							AlguiMemory.clearResult();//清空搜索结果    




                            //右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
                            AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "开启成功！", 2000);

                        } else {
                            //关闭时执行的内

						
                            //右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
                            AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "无法关闭！", 2000);
                        }
                    }
                }
            
        );
        AlGui.GUI(context).addSwitch
		(
			//开关按钮属性配置🛠️
			折叠菜单1,
			//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"金杆无限怒气", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：无限需激活要4星有可以不用激活", 9, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
				@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
				public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
					//开关按钮点击时将执行这里的内容
					//这将获取到开关的文本
					String switchText = aSwitch.getText().toString();
					//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
						//开启时执行的内容

						//修改值不够就像上面这样添加
						AlguiMemory.clearResult();//清空搜索结果    AlguiMemory.clearResult();//清空搜索结果
						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						
						AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
						AlguiMemory.MemoryOffset("300", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征
						AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
						AlguiMemory.MemoryOffset("600", AlguiMemory.TYPE_DOUBLE, 0x18);//副特			
						AlguiMemory.MemoryWrite("600000", AlguiMemory.TYPE_DOUBLE, 0x18);//修改值
                        AlguiMemory.MemoryWrite("1050", AlguiMemory.TYPE_DOUBLE, 0x0);//修改值

						AlguiMemory.clearResult();//清空搜索结果    




						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "开启成功！", 2000);

					} else {
						//关闭时执行的内

										//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "无法关闭！", 2000);
					}
				}
			}

        );
	        


		AlGui.GUI(context).addSwitch
        (
            折叠菜单1,
			//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"紫杆无限锁鱼", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：跑不掉", 8, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
				@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
				public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
					//开关按钮点击时将执行这里的内容
					//这将获取到开关的文本
					String switchText = aSwitch.getText().toString();
					//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
						//开启时执行的内容

						AlguiMemory.clearResult();//清空搜索结果
						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						
						AlguiMemory.RangeMemorySearch("1046", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("200", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
						
						AlguiMemory.MemoryWrite("100000", AlguiMemory.TYPE_DOUBLE, 0x18);//修改值
						//修改值不够就像上面这样添加
					 
						AlguiMemory.clearResult();//清空搜索结果*/      

						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "此功能无法关闭需要重启游戏恢复正常", "开启成功！", 5000);

					} else {
						//关闭时执行的内容
						
						//修改值不够就像上面这样添加
						
				        
				

						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "关闭成功！", 5000);
					}
				}
			}

        );
		
		
		AlGui.GUI(context).addSwitch
        (
            折叠菜单1,
			//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"金杆无限锁鱼", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：金色的鱼竿", 8, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
				@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
				public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
					//开关按钮点击时将执行这里的内容
					//这将获取到开关的文本
					String switchText = aSwitch.getText().toString();
					//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
						//开启时执行的内容

						AlguiMemory.clearResult();//清空搜索结果
						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名

						AlguiMemory.RangeMemorySearch("1046", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("300", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
	                    AlguiMemory.RangeMemorySearch("1046", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("600", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码

						AlguiMemory.MemoryWrite("100000", AlguiMemory.TYPE_DOUBLE, 0x18);//修改值
						//修改值不够就像上面这样添加
					
						AlguiMemory.clearResult();//清空搜索结果*/      

						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "此功能无法关闭需要重启游戏恢复正常", "开启成功！", 5000);

					} else {
						//关闭时执行的内容

						//修改值不够就像上面这样添加

						

						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "关闭成功！", 5000);
					}
				}
			}

        );

		

		
//___________________________________________________________________________________________________________________________

//___________________________________________________________________________________________________________________________

//___________________________________________________________________________________________________________________________
		
		LinearLayout 折叠菜单2= AlGui.GUI(context).addCollapse
        ( 
            AlGui.GUI(context).getMenuScrollingListLayout(),//父布局
            "蓝色鱼竿激活星级", 16, 0xFFFF0DFF, null,//折叠菜单文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
            3,//折叠菜单圆角半径
            0x6600FFFF,//折叠菜单背景颜色
            0, 0xFFC5CAE9,//折叠菜单描边大小，描边颜色
            false//折叠菜单默认是否展开 (true=默认展开，false=默认不展开)
        );

        //添加一条线 {参数：父布局，线的厚度，线的颜色，线的方向(true=横向 false=竖向)}
        AlGui.GUI(context).addLine(折叠菜单2, 1f, 0xFFE0E0E0, true);

        //添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
        AlGui.GUI(context).addTextView(折叠菜单2, "蓝色鱼竿满级修改区", 11, 0xE3FF00FF, null);
		
		
		
		
		
		AlGui.GUI(context).addTextView(折叠菜单2, "夜光曲", 15, 0xE3FF00FF, null);
   
		AlGui.GUI(context).addEditText
        (
			折叠菜单2,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500001", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码			
								
						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {
					
                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );

//___________________________________________________________________________________________________________________________

		
		AlGui.GUI(context).addTextView(折叠菜单2, "乐控", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单2,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500002", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码

					
						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
//___________________________________________________________________________________________________________________________
		
		AlGui.GUI(context).addTextView(折叠菜单2, "卓越2号", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单2,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500004", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		

//___________________________________________________________________________________________________________________________

		
		AlGui.GUI(context).addTextView(折叠菜单2, "魔多1820", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单2,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500003", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
			AlGui.GUI(context).addTextView(折叠菜单2, "小精灵", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单2,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500005", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
			AlGui.GUI(context).addTextView(折叠菜单2, "蓝鸟", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单2,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500006", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
			AlGui.GUI(context).addTextView(折叠菜单2, "珊瑚一号", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单2,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500007", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
			AlGui.GUI(context).addTextView(折叠菜单2, "美人鱼", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单2,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500008", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
		
		
		
		
//_________________菜单3__________________________________________________________________________________________________________
		
		LinearLayout 折叠菜单3= AlGui.GUI(context).addCollapse
        ( 
            AlGui.GUI(context).getMenuScrollingListLayout(),//父布局
            "紫色鱼竿激活星级", 16, 0xFFFF0DFF, null,//折叠菜单文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
            3,//折叠菜单圆角半径
            0x6600FFFF,//折叠菜单背景颜色
            0, 0xFFC5CAE9,//折叠菜单描边大小，描边颜色
            false//折叠菜单默认是否展开 (true=默认展开，false=默认不展开)
        );

        //添加一条线 {参数：父布局，线的厚度，线的颜色，线的方向(true=横向 false=竖向)}
        AlGui.GUI(context).addLine(折叠菜单3, 1f, 0xFFE0E0E0, true);

        //添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
        AlGui.GUI(context).addTextView(折叠菜单3, "紫色鱼竿满级修改区", 11, 0xE3FF00FF, null);

		
		AlGui.GUI(context).addTextView(折叠菜单3, "光轮3000", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单3,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500011", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
		//添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
     

		
		AlGui.GUI(context).addTextView(折叠菜单3, "狙击手", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单3,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500012", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
		
		//添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
        
		
		AlGui.GUI(context).addTextView(折叠菜单3, "钓轻松", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单3,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500013", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
		
			
		AlGui.GUI(context).addTextView(折叠菜单3, "乐逍遥", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单3,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500014", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
			
		AlGui.GUI(context).addTextView(折叠菜单3, "孤勇者", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单3,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500015", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
        
        
        
        
        
        
        	
		AlGui.GUI(context).addTextView(折叠菜单3, "幻境", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单3,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500016", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
		
			
		AlGui.GUI(context).addTextView(折叠菜单3, "伯爵炫", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单3,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500018", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
        
        
        
        
        	
		AlGui.GUI(context).addTextView(折叠菜单3, "幻刃", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单3,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500017", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
//________________________________________________________________________________________________________________________
		
		

		
//___________________________________________________________________________________________________________________________
		
		LinearLayout 折叠菜单4= AlGui.GUI(context).addCollapse
        ( 
            AlGui.GUI(context).getMenuScrollingListLayout(),//父布局
            "金色鱼竿激活星级", 16, 0xFFFF0DFF, null,//折叠菜单文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
            3,//折叠菜单圆角半径
            0x6600FFFF,//折叠菜单背景颜色
            0, 0xFFC5CAE9,//折叠菜单描边大小，描边颜色
            false//折叠菜单默认是否展开 (true=默认展开，false=默认不展开)
        );

        //添加一条线 {参数：父布局，线的厚度，线的颜色，线的方向(true=横向 false=竖向)}
        AlGui.GUI(context).addLine(折叠菜单4, 1f, 0xFFE0E0E0, true);

        //添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
        AlGui.GUI(context).addTextView(折叠菜单4, "金色鱼竿修改区", 11, 0xE3FF00FF, null);
        
        
        
        
        
        
        	
		AlGui.GUI(context).addTextView(折叠菜单4, "维纳斯", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单4,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500021", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




AlGui.GUI(context).addTextView(折叠菜单4, "灵眸一号", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单4,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500022", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




AlGui.GUI(context).addTextView(折叠菜单4, "波塞冬", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单4,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500023", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );





AlGui.GUI(context).addTextView(折叠菜单4, "王者归来", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单4,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500024", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );





AlGui.GUI(context).addTextView(折叠菜单4, "皇冠典藏", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单4,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500025", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




AlGui.GUI(context).addTextView(折叠菜单4, "无限帆", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单4,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500026", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




AlGui.GUI(context).addTextView(折叠菜单4, "王者大物", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单4,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500027", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




AlGui.GUI(context).addTextView(折叠菜单4, "奇妙幻境", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单4,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.official");//设置包名
						AlguiMemory.RangeMemorySearch("500028", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );


LinearLayout 折叠菜单5= AlGui.GUI(context).addCollapse
        ( 
            AlGui.GUI(context).getMenuScrollingListLayout(),//父布局
            "百度渠道服专用区", 16, 0xFFFFFFFF, null,//折叠菜单文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
            3,//折叠菜单圆角半径
            0xFF0000FF,//折叠菜单背景颜色
            0, 0xFF0000FF,//折叠菜单描边大小，描边颜色
            false//折叠菜单默认是否展开 (true=默认展开，false=默认不展开)
        );

        //添加一条线 {参数：父布局，线的厚度，线的颜色，线的方向(true=横向 false=竖向)}
        AlGui.GUI(context).addLine(折叠菜单5, 1f, 0xFFE0E0E0, true);

      
		


        LinearLayout 折叠菜单6= AlGui.GUI(context).addCollapse
        ( 
            AlGui.GUI(context).getMenuScrollingListLayout(),//父布局
            "功能菜单", 16, 0xFFFF0DFF, null,//折叠菜单文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
            3,//折叠菜单圆角半径
            0x6600FFFF,//折叠菜单背景颜色
            0, 0xFFC5CAE9,//折叠菜单描边大小，描边颜色
            false//折叠菜单默认是否展开 (true=默认展开，false=默认不展开)
        );

        //添加一条线 {参数：父布局，线的厚度，线的颜色，线的方向(true=横向 false=竖向)}
        AlGui.GUI(context).addLine(折叠菜单6, 1f, 0xFFE0E0E0, true);

        //添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
        AlGui.GUI(context).addTextView(折叠菜单6, "功能区", 11, 0xE3FF00FF, null);
	
		
		
		
			
		
		AlGui.GUI(context).addTextView(折叠菜单6, "可以自定义输入加速多少倍正常速度为0.14", 11, 0xE3FF00FF, null);


		//添加一个带按钮的输入框
        AlGui.GUI(context).addEditText
        (
			折叠菜单6,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "0.5", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "启动加速", //按钮文本颜色，按钮文本
            0, 0xFF5492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_CODE_APP);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("-0.69999998808", AlguiMemory.TYPE_FLOAT);//主特征码
                       

						AlguiMemory.MemoryWriteFreeze(editText, AlguiMemory.TYPE_FLOAT, 0x8);//修改值
					
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "加速成功", "修改成功！", 5000);
                    } else {
                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		AlGui.GUI(context).addEditText
        (
			折叠菜单6,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "0.14", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "关闭加速", //按钮文本颜色，按钮文本
            0, 0xFF5492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {
						
						AlguiMemory.setRange(AlguiMemory.RANGE_CODE_APP);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("-0.69999998808", AlguiMemory.TYPE_FLOAT);//主特征码
                        

						AlguiMemory.MemoryWriteFreeze(editText, AlguiMemory.TYPE_FLOAT, 0x8);//修改值
						
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "关闭成功", "修改成功！", 5000);
                    } else {
                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );

		
		
		//添加一个开关按钮
		AlGui.GUI(context).addSwitch
		(
		//开关按钮属性配置🛠️
		折叠菜单6,
		//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
		"开启自动满怒气(注意说明)", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：必须要一格怒气才能激活只需要激活一次即可", 9, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
			@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
			public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
			//开关按钮点击时将执行这里的内容
			//这将获取到开关的文本
				String switchText = aSwitch.getText().toString();
				//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
					//开启时执行的内容

					AlguiMemory.clearResult();//清空搜索结果    AlguiMemory.clearResult();//清空搜索结果
					AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("10000", AlguiMemory.TYPE_DOUBLE);//主特征
				    	AlguiMemory.MemoryOffset("0.0", AlguiMemory.TYPE_DOUBLE, 0x58);//副特征码	
				    	AlguiMemory.MemoryOffset("0.0", AlguiMemory.TYPE_DOUBLE, 0x70);//副特征码
	                    AlguiMemory.RangeMemorySearch("30000", AlguiMemory.TYPE_DOUBLE);//主特征
				        AlguiMemory.MemoryOffset("0.0", AlguiMemory.TYPE_DOUBLE, 0x58);//副特征	
					    AlguiMemory.MemoryOffset("0.0", AlguiMemory.TYPE_DOUBLE, 0x70);//副特征码
					
					
						AlguiMemory.MemoryWriteFreeze("30000", AlguiMemory.TYPE_DOUBLE, 0x0);//修改值
						//修改值不够就像上面这样添加
						AlguiMemory.startFreeze();
						AlguiMemory.clearResult();//清空搜索结果    




						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "开启成功！", 2000);

                        } else {
						//关闭时执行的内容


					//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "无法关闭！", 2000);
                        }
						}
						}

					);
				
		

		


        
        
        
        

        
        
        
        


		
                
                
        AlGui.GUI(context).addSwitch
		(
			//开关按钮属性配置🛠️
			折叠菜单6,
			//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"蓝杆无限怒气", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：无限需激活要3星有可以不用激活", 9, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
				@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
				public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
					//开关按钮点击时将执行这里的内容
					//这将获取到开关的文本
					String switchText = aSwitch.getText().toString();
					//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
						//开启时执行的内容

						//修改值不够就像上面这样添加
						AlguiMemory.clearResult();//清空搜索结果    AlguiMemory.clearResult();//清空搜索结果
						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名

						AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
						AlguiMemory.MemoryOffset("150", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
						AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
						AlguiMemory.MemoryOffset("300", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
						
						AlguiMemory.MemoryWrite("600000", AlguiMemory.TYPE_DOUBLE, 0x18);//修改值
                        AlguiMemory.MemoryWrite("1050", AlguiMemory.TYPE_DOUBLE, 0x0);//修改值

						//修改值不够就像上面这样添加
						AlguiMemory.clearResult();//清空搜索结果    




						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "开启成功！", 2000);

					} else {
					
		
						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "无法关闭！", 2000);
					}
				}
			}

        );
        
         AlGui.GUI(context).addSwitch
            (
                //开关按钮属性配置🛠️
				折叠菜单6,
                //开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
                "紫杆无限怒气", 11, 0xFFFFFFFF, null,
                //开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
                "说明：无限需激活要3星有可以不用激活", 9, 0xE4FF1700, null,
                //开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
                0xFF4CAF50, 0xFF66BB6A,
                //开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
                0xFFF44336, 0xFFEF5350,
                //开关按钮事件监听器
                new AlGui.T_SwitchOnChangeListener(){
                    @Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
                    public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
                        //开关按钮点击时将执行这里的内容
                        //这将获取到开关的文本
                        String switchText = aSwitch.getText().toString();
                        //这将获取到描述信息的文本
                        String descText=desc.getText().toString();
                        //isChecked为开关状态
                        if (isChecked) {
                            //开启时执行的内容
						
							//修改值不够就像上面这样添加
							AlguiMemory.clearResult();//清空搜索结果    AlguiMemory.clearResult();//清空搜索结果
							AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
							AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
					
							AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
							AlguiMemory.MemoryOffset("200", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
							
							AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
							AlguiMemory.MemoryOffset("400", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
							
							
						AlguiMemory.MemoryWrite("600000", AlguiMemory.TYPE_DOUBLE, 0x18);//修改值
                        AlguiMemory.MemoryWrite("1050", AlguiMemory.TYPE_DOUBLE, 0x0);//修改值

							//修改值不够就像上面这样添加
							AlguiMemory.clearResult();//清空搜索结果    




                            //右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
                            AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "开启成功！", 2000);

                        } else {
                            //关闭时执行的内

							//修改值不够就像上面这样添加
										//修改值不够就像上面这样添加
					

                            //右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
                            AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "无法关闭！", 2000);
                        }
                    }
                }
            
        );
        
             AlGui.GUI(context).addSwitch
		(
			//开关按钮属性配置🛠️
			折叠菜单6,
			//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"金杆无限怒气", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：无限需激活要3星有可以不用激活", 9, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
				@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
				public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
					//开关按钮点击时将执行这里的内容
					//这将获取到开关的文本
					String switchText = aSwitch.getText().toString();
					//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
						//开启时执行的内容

						//修改值不够就像上面这样添加
						AlguiMemory.clearResult();//清空搜索结果    AlguiMemory.clearResult();//清空搜索结果
						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						
						AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
						AlguiMemory.MemoryOffset("300", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征
						AlguiMemory.RangeMemorySearch("1045", AlguiMemory.TYPE_DOUBLE);//主特征
							AlguiMemory.MemoryOffset("600", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
							
							
						AlguiMemory.MemoryWrite("600000", AlguiMemory.TYPE_DOUBLE, 0x18);//修改值
                        AlguiMemory.MemoryWrite("1050", AlguiMemory.TYPE_DOUBLE, 0x0);//修改值

						AlguiMemory.clearResult();//清空搜索结果    




						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "开启成功！", 2000);

					} else {
						//关闭时执行的内

										//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "无法关闭！", 2000);
					}
				}
			}

        );
	        
        

		AlGui.GUI(context).addSwitch
        (
            折叠菜单6,
			//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"紫杆无限锁鱼", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：两星以上使用跑不掉", 8, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
				@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
				public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
					//开关按钮点击时将执行这里的内容
					//这将获取到开关的文本
					String switchText = aSwitch.getText().toString();
					//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
						//开启时执行的内容

						AlguiMemory.clearResult();//清空搜索结果
						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						
						AlguiMemory.RangeMemorySearch("1046", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("200", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
						AlguiMemory.RangeMemorySearch("1046", AlguiMemory.TYPE_DOUBLE);//主特征
							AlguiMemory.MemoryOffset("400", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
							
							
						AlguiMemory.MemoryWrite("100000", AlguiMemory.TYPE_DOUBLE, 0x18);//修改值
						//修改值不够就像上面这样添加
					 
						AlguiMemory.clearResult();//清空搜索结果*/      

						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "此功能无法关闭需要重启游戏恢复正常", "开启成功！", 5000);

					} else {
						//关闭时执行的内容
						
						//修改值不够就像上面这样添加
						
				        
				

						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "关闭成功！", 5000);
					}
				}
			}

        );
		
		
		AlGui.GUI(context).addSwitch
        (
            折叠菜单6,
			//开关文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"金杆无限锁鱼", 11, 0xFFFFFFFF, null,
			//开关描述文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
			"说明：3⭐️以上金色的鱼竿", 8, 0xE4FF1700, null,
			//开关圆柄开启时的颜色 和 开关轨迹开启时的颜色
			0xFF4CAF50, 0xFF66BB6A,
			//开关圆柄关闭时的颜色 和 开关轨迹关闭时的颜色
			0xFFF44336, 0xFFEF5350,
			//开关按钮事件监听器
			new AlGui.T_SwitchOnChangeListener(){
				@Override//事件中你可以获取到： aSwitch=开关对象 desc=描述信息对象 isChecked=开关状态
				public void onClick(CompoundButton aSwitch, TextView desc, boolean isChecked) {
					//开关按钮点击时将执行这里的内容
					//这将获取到开关的文本
					String switchText = aSwitch.getText().toString();
					//这将获取到描述信息的文本
					String descText=desc.getText().toString();
					//isChecked为开关状态
					if (isChecked) {
						//开启时执行的内容

						AlguiMemory.clearResult();//清空搜索结果
						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
						AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名

						AlguiMemory.RangeMemorySearch("1046", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("300", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
                        AlguiMemory.RangeMemorySearch("1046", AlguiMemory.TYPE_DOUBLE);//主特征
						AlguiMemory.MemoryOffset("600", AlguiMemory.TYPE_DOUBLE, 0x18);//副特征码
							
							
						AlguiMemory.MemoryWrite("100000", AlguiMemory.TYPE_DOUBLE, 0x18);//修改值
						//修改值不够就像上面这样添加
					   
						AlguiMemory.clearResult();//清空搜索结果*/      

						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "此功能无法关闭需要重启游戏恢复正常", "开启成功！", 5000);

					} else {
						//关闭时执行的内容

						//修改值不够就像上面这样添加

						
					    
						AlguiMemory.clearResult();//清空搜索结果*/      
						


						//右下角气泡通知 (如需了解详情，请看最后面的拓展性功能注释)
						AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, switchText, "关闭成功！", 5000);
					}
				}
			}

        );


	

		

//___________________________________________________________________________________________________________________________

//___________________________________________________________________________________________________________________________

//___________________________________________________________________________________________________________________________
		
		LinearLayout 折叠菜单7= AlGui.GUI(context).addCollapse
        ( 
            AlGui.GUI(context).getMenuScrollingListLayout(),//父布局
            "蓝色鱼竿激活星级", 16, 0xFFFF0DFF, null,//折叠菜单文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
            3,//折叠菜单圆角半径
            0x6600FFFF,//折叠菜单背景颜色
            0, 0xFFC5CAE9,//折叠菜单描边大小，描边颜色
            false//折叠菜单默认是否展开 (true=默认展开，false=默认不展开)
        );

        //添加一条线 {参数：父布局，线的厚度，线的颜色，线的方向(true=横向 false=竖向)}
        AlGui.GUI(context).addLine(折叠菜单7, 1f, 0xFFE0E0E0, true);

        //添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
        AlGui.GUI(context).addTextView(折叠菜单7, "蓝色鱼竿满级修改区", 11, 0xE3FF00FF, null);
		
		
		
		
		
		AlGui.GUI(context).addTextView(折叠菜单7, "夜光曲", 15, 0xE3FF00FF, null);
   
		AlGui.GUI(context).addEditText
        (
			折叠菜单7,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500001", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码			
								
						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {
					
                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );

//___________________________________________________________________________________________________________________________

		
		AlGui.GUI(context).addTextView(折叠菜单7, "乐控", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单7,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500002", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码

					
						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
//___________________________________________________________________________________________________________________________
		
		AlGui.GUI(context).addTextView(折叠菜单7, "卓越2号", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单7,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500004", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		

//___________________________________________________________________________________________________________________________

		
		AlGui.GUI(context).addTextView(折叠菜单7, "魔多1820", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单7,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500003", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
			AlGui.GUI(context).addTextView(折叠菜单7, "小精灵", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单7,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500005", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
			AlGui.GUI(context).addTextView(折叠菜单7, "蓝鸟", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单7,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500006", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
			AlGui.GUI(context).addTextView(折叠菜单7, "珊瑚一号", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单7,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500007", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
			AlGui.GUI(context).addTextView(折叠菜单7, "美人鱼", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单7,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500008", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
		
		
		
		
//_________________菜单3__________________________________________________________________________________________________________
		
		LinearLayout 折叠菜单8= AlGui.GUI(context).addCollapse
        ( 
            AlGui.GUI(context).getMenuScrollingListLayout(),//父布局
            "紫色鱼竿激活星级", 16, 0xFFFF0DFF, null,//折叠菜单文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
            3,//折叠菜单圆角半径
            0x6600FFFF,//折叠菜单背景颜色
            0, 0xFFC5CAE9,//折叠菜单描边大小，描边颜色
            false//折叠菜单默认是否展开 (true=默认展开，false=默认不展开)
        );

        //添加一条线 {参数：父布局，线的厚度，线的颜色，线的方向(true=横向 false=竖向)}
        AlGui.GUI(context).addLine(折叠菜单8, 1f, 0xFFE0E0E0, true);

        //添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
        AlGui.GUI(context).addTextView(折叠菜单8, "紫色鱼竿满级修改区", 11, 0xE3FF00FF, null);

		
		AlGui.GUI(context).addTextView(折叠菜单8, "光轮3000", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单8,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500011", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
		//添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
     

		
		AlGui.GUI(context).addTextView(折叠菜单8, "狙击手", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单8,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500012", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
		
		//添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
        
		
		AlGui.GUI(context).addTextView(折叠菜单8, "钓轻松", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单8,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500013", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
		
			
		AlGui.GUI(context).addTextView(折叠菜单8, "乐逍遥", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单8,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500014", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
			
		AlGui.GUI(context).addTextView(折叠菜单8, "孤勇者", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单8,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500015", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
        
        
        
        
        
        
        	
		AlGui.GUI(context).addTextView(折叠菜单8, "幻境", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单8,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500016", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
		
		
		
		
			
		AlGui.GUI(context).addTextView(折叠菜单8, "伯爵炫", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单8,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500018", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
        
        
        
        
        	
		AlGui.GUI(context).addTextView(折叠菜单8, "幻刃", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单8,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500017", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						//紫色等级2
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );
		
//________________________________________________________________________________________________________________________
		
		

		
//___________________________________________________________________________________________________________________________
		
		LinearLayout 折叠菜单9= AlGui.GUI(context).addCollapse
        ( 
            AlGui.GUI(context).getMenuScrollingListLayout(),//父布局
            "金色鱼竿激活星级", 16, 0xFFFF0DFF, null,//折叠菜单文本，文本大小，文本颜色，文本字体(null代表跟随系统字体)
            3,//折叠菜单圆角半径
            0x6600FFFF,//折叠菜单背景颜色
            0, 0xFFC5CAE9,//折叠菜单描边大小，描边颜色
            false//折叠菜单默认是否展开 (true=默认展开，false=默认不展开)
        );

        //添加一条线 {参数：父布局，线的厚度，线的颜色，线的方向(true=横向 false=竖向)}
        AlGui.GUI(context).addLine(折叠菜单9, 1f, 0xFFE0E0E0, true);

        //添加一个文本 {参数：父布局，文本内容，文本大小，文本颜色，文本字体(null代表跟随系统字体)}
        AlGui.GUI(context).addTextView(折叠菜单9, "金色鱼竿修改区", 11, 0xE3FF00FF, null);
        
        
        
        
        
        
        	
		AlGui.GUI(context).addTextView(折叠菜单9, "维纳斯", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单9,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500021", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




AlGui.GUI(context).addTextView(折叠菜单9, "灵眸一号", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单9,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500022", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




AlGui.GUI(context).addTextView(折叠菜单9, "波塞冬", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单9,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500023", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );





AlGui.GUI(context).addTextView(折叠菜单9, "王者归来", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单9,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500024", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );





AlGui.GUI(context).addTextView(折叠菜单9, "皇冠典藏", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单9,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500025", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




AlGui.GUI(context).addTextView(折叠菜单9, "无限帆", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单9,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500026", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




AlGui.GUI(context).addTextView(折叠菜单9, "王者大物", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单9,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500027", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




AlGui.GUI(context).addTextView(折叠菜单9, "奇妙幻境", 15, 0xE3FF00FF, null);

		AlGui.GUI(context).addEditText
        (
			折叠菜单9,

            13, null,//输入框和按钮的文本大小，输入框和按钮的文本字体(null代表跟随系统字体)
            0xFFF8F8FF, "输入鱼竿当前等级", //输入框提示内容颜色，输入框提示内容
            0xC200FF00, "", //输入框输入内容颜色，输入框默认输入内容
            0, 0x25ffffff,  1f, 0xFF5492E5,//输入框圆角半径, 输入框背景色, 输入框描边厚度, 输入框描边颜色
            0xFFFFFFFF, "确认修改", //按钮文本颜色，按钮文本
            0, 0x665492E5, 0, 0xFFFFFFFF,//按钮圆角半径，按钮背景色，按钮描边厚度，按钮描边颜色

            //输入框事件监听器
            new AlGui.T_EditTextOnChangeListener(){
                @Override
                public void beforeTextChanged(EditText edit, CharSequence charSequence, int start, int count, int after) {
                    // 在文本变化之前执行的内容
                }
                @Override
                public void onTextChanged(EditText edit, CharSequence charSequence, int start, int before, int count) {
                    // 在文本变化时执行的内容
                }
                @Override
                public void afterTextChanged(EditText edit, Editable editable) {
                    // 在文本变化之后执行的内容
                    //进行检测 只支持输入数字
                    //检测非法字符 如果检测到则清除  
                    if (!editable.toString().matches("-?[0-9]*(\\.[0-9]*)?")) {
                        // 输入包含非法字符，进行清除操作
                        String cleanedInput = editable.toString().replaceAll("[^-0-9.]", "");

                        // 清除多余的负号，保留第一个负号
                        int firstMinusIndex = cleanedInput.indexOf("-");
                        if (firstMinusIndex != -1) {
                            cleanedInput = cleanedInput.substring(0, firstMinusIndex + 1) + 
                                cleanedInput.substring(firstMinusIndex + 1).replace("-", "");
                        }

                        // 清除多余的小数点
                        cleanedInput = cleanedInput.replaceAll("\\.(?=.*\\.)", "");

                        edit.setText(cleanedInput);
                        edit.setSelection(cleanedInput.length());
                    }


                }
                //输入框按钮点击事件
                @Override
                public  void buttonOnClick(EditText edit, View button, TextView buttonText, boolean isChecked) {
                    //这样来获取输入框当前输入的内容
                    String editText=edit.getText().toString() != null ?edit.getText().toString(): "";
                    //输入框内容不为空才进
                    if (!editText.isEmpty()) {

						AlguiMemory.setRange(AlguiMemory.RANGE_ANONYMOUS);//设置内存
                        AlguiMemory.setPackageName("com.xuejing.smallfish.g.baidu");//设置包名
						AlguiMemory.RangeMemorySearch("500028", AlguiMemory.TYPE_DOUBLE);//主特征码
                        AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x4);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x8);//副特征码
						//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x1C);//副特征码
						AlguiMemory.MemoryOffset(editText, AlguiMemory.TYPE_DOUBLE, -0x30);//副特征码
						AlguiMemory.MemoryOffset("0", AlguiMemory.TYPE_DOUBLE, -0x34);//副特征码


						 //等级
						AlguiMemory.MemoryWriteFreeze("3", AlguiMemory.TYPE_DOUBLE, -0x18);//修改值
						AlguiMemory.startFreeze();//开启冻结线程
                        AlguiMemory.clearResult();//清空搜索结果

                        AlGuiBubbleNotification.Inform(context).showSuccessNotification_Simplicity(null, "修改鱼竿等级", "修改成功！", 5000);
                    } else {

                        AlGuiBubbleNotification.Inform(context).showAlertNotification_Simplicity(null, "修改失败", "请输入合法数字！", 5000);
                    }


                }
            }

        );




}
}

        
		
